{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NNLM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "{'名': 0, '是': 1, '她': 2, '生': 3, '一': 4, '学': 5}\n",
      "{0: '名', 1: '是', 2: '她', 3: '生', 4: '一', 5: '学'}\n"
     ]
    }
   ],
   "source": [
    "raw_sentence = \"她是一名学生\"\n",
    "# 第1步：单词索引\n",
    "word_list = \" \".join(raw_sentence).split()\n",
    "word_list = list(set(word_list))\n",
    "word2id = {w: i for i, w in enumerate(word_list)}\n",
    "id2word = {i: w for i, w in enumerate(word_list)}\n",
    "n_class = len(word2id)\n",
    "print(n_class)\n",
    "print(word2id)\n",
    "print(id2word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[2, 1],\n",
      "        [1, 4],\n",
      "        [4, 0],\n",
      "        [0, 5]])\n",
      "tensor([4, 0, 5, 3])\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# 构造训练数据\n",
    "def make_batch(raw_sentence, word2id, n_step):\n",
    "    input_batch, target_batch = [], []\n",
    "    word_list = list(raw_sentence)\n",
    "    for i in range(n_step, len(word_list)):  # 目标词索引迭代\n",
    "        target = word_list[i]  # 获取目标词\n",
    "        input_index = [word2id[word_list[j]] for j in range((i - n_step), i)]  # 获取目标词相关输入数据集\n",
    "        target_index = word2id[target]  # 目标词索引\n",
    "        input_batch.append(input_index)\n",
    "        target_batch.append(target_index)\n",
    "\n",
    "    return input_batch, target_batch\n",
    "n_step = 2\n",
    "input_batch, target_batch = make_batch(raw_sentence, word2id, n_step)\n",
    "# 数据转为tensor\n",
    "input_batch,target_batch = torch.LongTensor(input_batch), torch.LongTensor(target_batch)\n",
    "print(input_batch)\n",
    "print(target_batch)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 249 cost = 0.487509\n",
      "Epoch: 499 cost = 0.117576\n",
      "Epoch: 749 cost = 0.047869\n",
      "Epoch: 999 cost = 0.025989\n",
      "[['她', '是'], ['是', '一'], ['一', '名'], ['名', '学']]\n",
      "['一', '名', '学', '生']\n",
      "['一', '名', '学', '生']\n",
      "名 -1.4445096 0.9377294\n",
      "\n",
      "是 1.208882 -1.3353053\n",
      "\n",
      "她 -0.34673855 -1.1590401\n",
      "\n",
      "生 0.11130011 0.7045475\n",
      "\n",
      "一 2.02665 1.0623003\n",
      "\n",
      "学 -0.86630344 1.1700238\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 第2步：构建模型\n",
    "import torch\n",
    "from torch import nn\n",
    "import torch.optim as optim\n",
    "import numpy\n",
    "\n",
    "class NNLM(nn.Module):\n",
    "   def __init__(self):\n",
    "       super(NNLM, self).__init__()\n",
    "       self.embeddings = nn.Embedding(n_class, m)# m代表词向量维度\n",
    "       self.hidden1 = nn.Linear(n_step * m, n_hidden, bias=False) # n_step窗口移动步长\n",
    "       self.ones = nn.Parameter(torch.ones(n_hidden))\n",
    "       self.hidden2 = nn.Linear(n_hidden, n_class, bias=False)\n",
    "       self.hidden3 = nn.Linear(n_step * m, n_class, bias=False) #final layer\n",
    "       self.bias = nn.Parameter(torch.ones(n_class))\n",
    "       \n",
    "   def forward(self, X):\n",
    "       X = self.embeddings(X) # embeddings\n",
    "       X = X.view(-1, n_step * m) # first layer\n",
    "       \n",
    "       tanh = torch.tanh(self.ones + self.hidden1(X)) \n",
    "       output = self.bias + self.hidden3(X) + self.hidden2(tanh)\n",
    "       return output\n",
    "\n",
    "# 第3步：定义损失函数\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "# 第4步：执行训练\n",
    "m = 2  # 词向量的维度\n",
    "n_hidden = 2  # 隐层个数\n",
    "n_step = 2\n",
    "\n",
    "model = NNLM()\n",
    "# 定义优化器\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
    "# 训练10次\n",
    "for epoch in range(1000):\n",
    "    optimizer.zero_grad()  # 梯度归零\n",
    "    output = model(input_batch)\n",
    "    # print(target_batch)\n",
    "    # print(output)\n",
    "\n",
    "    # output : [batch_size, n_class], target_batch : [batch_size]\n",
    "    loss = criterion(output, target_batch)\n",
    "    if (epoch + 1) % 250 == 0:\n",
    "        print('Epoch:', '%d' % (epoch), 'cost =', '{:.6f}'.format(loss))\n",
    "    loss.backward()  # 反向传播计算 每个参数的梯度值\n",
    "    optimizer.step()  # 每一个参数的梯度值更新\n",
    "\n",
    "# Predict\n",
    "predict = model(input_batch).data.max(1, keepdim=True)[1]\n",
    "print([[id2word[n.item()],id2word[m.item()]] for n,m in input_batch.squeeze()])\n",
    "print([id2word[n.item()] for n in target_batch.squeeze()])\n",
    "print([id2word[n.item()] for n in predict.squeeze()])\n",
    "\n",
    "# embedding\n",
    "embeddings = model.embeddings.weight.detach().numpy()\n",
    "for i, word in id2word.items():\n",
    "    embedding = ' '.join(map(str, embeddings[i]))\n",
    "    print('{} {}\\n'.format(word, embedding))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Word2Vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(['她', '是', '名', '学'], '一'), (['是', '一', '学', '生'], '名')]\n",
      "tensor([[2, 1, 0, 5],\n",
      "        [1, 4, 5, 3]])\n",
      "tensor([4, 0])\n"
     ]
    }
   ],
   "source": [
    "# ------------------------------------------CBOW---------------------------------------------------\n",
    "# 第1步：定义窗口函数\n",
    "def CBOW(raw_text, window_size=2):\n",
    "    data = []\n",
    "    for i in range(window_size, len(raw_text) - window_size):\n",
    "        context = [raw_text[i - window_size], raw_text[i - (window_size - 1)], raw_text[i + (window_size - 1)], raw_text[i + window_size]]\n",
    "        target = raw_text[i]\n",
    "        data.append((context, target))\n",
    "    return data\n",
    "raw_text = raw_sentence\n",
    "# raw_text = \"她正在踢毽子\"\n",
    "data = CBOW(raw_text)\n",
    "input_batch = []\n",
    "target_batch = []\n",
    "for context, target in data:\n",
    "    context = [word2id[word] for word in context]\n",
    "    target = word2id[target]\n",
    "    input_batch.append(context)\n",
    "    target_batch.append(target)\n",
    "input_batch,target_batch = torch.LongTensor(input_batch), torch.LongTensor(target_batch)\n",
    "print(data)\n",
    "print(input_batch)\n",
    "print(target_batch)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 249 cost = 0.176190\n",
      "Epoch: 499 cost = 0.055939\n",
      "Epoch: 749 cost = 0.028641\n",
      "Epoch: 999 cost = 0.018194\n",
      "[['她', '是', '名', '学'], ['是', '一', '学', '生']]\n",
      "['一', '名']\n",
      "['一', '名']\n",
      "名 -1.913571 -0.5287815\n",
      "\n",
      "是 0.38029093 0.38815695\n",
      "\n",
      "她 -1.2846233 -0.5825117\n",
      "\n",
      "生 0.8827603 -0.4640295\n",
      "\n",
      "一 -0.2764802 0.5725048\n",
      "\n",
      "学 -1.0815939 0.032088272\n",
      "\n"
     ]
    }
   ],
   "source": [
    "word_to_ix = word2id\n",
    "vocab_size = n_class\n",
    "embedding_dim = 2\n",
    "\n",
    "# 第2步：构造模型\n",
    "class CBOW_Model(torch.nn.Module):\n",
    "   def __init__(self, vocab_size, embedding_dim):\n",
    "       super(CBOW_Model, self).__init__()\n",
    "       self.embeddings = nn.Embedding(vocab_size, embedding_dim)\n",
    "       self.linear1 = nn.Linear(embedding_dim, 128)\n",
    "       self.activation_function1 = nn.ReLU()\n",
    "       self.linear2 = nn.Linear(128, vocab_size)\n",
    "   def forward(self, inputs):\n",
    "       embeds = self.embeddings(inputs)\n",
    "       embeds = torch.mean(embeds, dim=1)\n",
    "       out = self.linear1(embeds)\n",
    "       out = self.activation_function1(out)\n",
    "       out = self.linear2(out)\n",
    "       return out\n",
    "model = CBOW_Model(vocab_size, embedding_dim)\n",
    "# 第3步：损失函数&优化函数\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.01)\n",
    "\n",
    "def make_context_vector(context, word_to_ix):\n",
    "    context_vector = torch.tensor([word_to_ix[w] for w in context], dtype=torch.long)\n",
    "    return context_vector\n",
    "\n",
    "loss_function = criterion\n",
    "\n",
    "# 第4步:执行训练\n",
    "for epoch in range(1000):\n",
    "    optimizer.zero_grad()\n",
    "    output = model(input_batch)\n",
    "    total_loss = loss_function(output, target_batch)\n",
    "    if (epoch + 1) % 250 == 0:\n",
    "        print('Epoch:', '%d' % (epoch), 'cost =', '{:.6f}'.format(total_loss))\n",
    "    \n",
    "    total_loss.backward()\n",
    "    optimizer.step()\n",
    "\n",
    "#Test\n",
    "predict = model(input_batch).data.max(1, keepdim=True)[1]\n",
    "print([[id2word[n.item()],id2word[m.item()],id2word[j.item()], id2word[k.item()]] for n,m,j,k in input_batch.squeeze()])\n",
    "print([id2word[n.item()] for n in target_batch.squeeze()])\n",
    "print([id2word[n.item()] for n in predict.squeeze()])\n",
    "\n",
    "# Embedding\n",
    "embeddings = model.embeddings.weight.detach().numpy()\n",
    "for i, word in id2word.items():\n",
    "    embedding = ' '.join(map(str, embeddings[i]))\n",
    "    print('{} {}\\n'.format(word, embedding))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['是', '她'], ['是', '一'], ['一', '是'], ['一', '名'], ['名', '一'], ['名', '学'], ['学', '名'], ['学', '生']]\n",
      "tensor([1, 1, 4, 4, 0, 0, 5, 5])\n",
      "tensor([2, 4, 1, 0, 4, 5, 0, 3])\n"
     ]
    }
   ],
   "source": [
    "# ------------------------------------------skip-gram---------------------------------------------------\n",
    "# 第1步：设置目标单词和上下文变量\n",
    "def skipgram(word_sequence, n_step=1):\n",
    "   skip_grams = []\n",
    "   for i in range(n_step, len(word_sequence) - n_step):\n",
    "       target = word_sequence[i]\n",
    "       context = [word_sequence[i - n_step], word_sequence[i + n_step]]\n",
    "       for w in context:\n",
    "           skip_grams.append([target, w])\n",
    "   return skip_grams\n",
    "\n",
    "word_sequence = raw_sentence\n",
    "# raw_text = \"她正在踢毽子\"\n",
    "data = skipgram(word_sequence)\n",
    "input_batch = []\n",
    "target_batch = []\n",
    "for context, target in data:\n",
    "    context = word2id[context]\n",
    "    target = word2id[target]\n",
    "    input_batch.append(context)\n",
    "    target_batch.append(target)\n",
    "input_batch,target_batch = torch.LongTensor(input_batch), torch.LongTensor(target_batch)\n",
    "print(data)\n",
    "print(input_batch)\n",
    "print(target_batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0250 cost = 1.629972\n",
      "Epoch: 0500 cost = 1.530012\n",
      "Epoch: 0750 cost = 1.520288\n",
      "Epoch: 1000 cost = 1.518516\n",
      "['是', '是', '一', '一', '名', '名', '学', '学']\n",
      "['她', '一', '是', '名', '一', '学', '名', '生']\n",
      "['名', '名', '名', '名', '名', '名', '生', '生']\n",
      "名 0.15025611 0.14911926\n",
      "\n",
      "是 -0.75049293 -0.449282\n",
      "\n",
      "她 -0.37733915 -0.014441499\n",
      "\n",
      "生 0.3594068 0.36600173\n",
      "\n",
      "一 0.26065895 0.7376212\n",
      "\n",
      "学 1.2444158 -1.6334755\n",
      "\n"
     ]
    }
   ],
   "source": [
    "voc_size = n_class\n",
    "embedding_size = 2\n",
    "\n",
    "# 第2步：构建模型\n",
    "class skipgramModel(nn.Module):\n",
    "   def __init__(self):\n",
    "       super(skipgramModel, self).__init__()\n",
    "       self.embedding = nn.Embedding(voc_size, embedding_size)\n",
    "       self.W = nn.Linear(embedding_size, embedding_size, bias=False)\n",
    "       self.WT = nn.Linear(embedding_size, voc_size, bias=False)\n",
    "   def forward(self, X):\n",
    "       embeddings = self.embedding(X)\n",
    "       hidden_layer = nn.functional.relu(self.W(embeddings))\n",
    "       output_layer = self.WT(hidden_layer)\n",
    "       return output_layer\n",
    "\n",
    "# 第3步：损失函数和优化器\n",
    "model = skipgramModel()\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# 第4步：执行训练\n",
    "for epoch in range(1000):\n",
    "    optimizer.zero_grad()\n",
    "    output = model(input_batch)\n",
    "    loss = criterion(output, target_batch)\n",
    "    if (epoch + 1) % 250 == 0:\n",
    "        print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.6f}'.format(loss))\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "#Test\n",
    "predict = model(input_batch).data.max(1, keepdim=True)[1]\n",
    "print([id2word[n.item()] for n in input_batch.squeeze()])\n",
    "print([id2word[n.item()] for n in target_batch.squeeze()])\n",
    "print([id2word[n.item()] for n in predict.squeeze()])\n",
    "\n",
    "# Embedding\n",
    "embeddings = model.embedding.weight.detach().numpy()\n",
    "for i, word in id2word.items():\n",
    "    embedding = ' '.join(map(str, embeddings[i]))\n",
    "    print('{} {}\\n'.format(word, embedding))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Position Embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7f5de4ba0ca0>"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x400 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x312.5 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "def getPositionEncoding(seq_len, d, n=10000):\n",
    "    P = np.zeros((seq_len, d))\n",
    "    for k in range(seq_len):\n",
    "        for i in np.arange(int(d/2)):\n",
    "            denominator = np.power(n, 2*i/d)\n",
    "            P[k, 2*i] = np.sin(k/denominator)\n",
    "            P[k, 2*i+1] = np.cos(k/denominator)\n",
    "    return P\n",
    "P = getPositionEncoding(seq_len=4, d=4, n=100)\n",
    "\n",
    "# 不同位置曲线的对比\n",
    "def plotSinusoid(k, d=512, n=10000):\n",
    "    x = np.arange(0, 100, 1)\n",
    "    denominator = np.power(n, 2*x/d)\n",
    "    y = np.sin(k/denominator)\n",
    "    plt.plot(x, y)\n",
    "    plt.title('k = ' + str(k))\n",
    "fig = plt.figure(figsize=(15, 4))    \n",
    "for i in range(4):\n",
    "    plt.subplot(141 + i)\n",
    "    plotSinusoid(i*4)\n",
    "\n",
    "# 可视化位置矩阵\n",
    "P = getPositionEncoding(seq_len=100, d=512, n=10000)\n",
    "cax = plt.matshow(P)\n",
    "plt.gcf().colorbar(cax)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Feed Forward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PositionwiseFeedForward(nn.Module):\n",
    "  def __init__(self, d_model: int, d_ffn: int, dropout: float = 0.1):\n",
    "    \"\"\"\n",
    "    Args:\n",
    "        d_model: dimension of embeddings\n",
    "        d_ffn: dimension of feed-forward network\n",
    "        dropout: probability of dropout occurring\n",
    "    \"\"\"\n",
    "    super().__init__()\n",
    "    self.w_1 = nn.Linear(d_model, d_ffn)\n",
    "    self.w_2 = nn.Linear(d_ffn, d_model)\n",
    "    self.dropout = nn.Dropout(dropout)\n",
    "  def forward(self, x):\n",
    "    \"\"\"\n",
    "    Args:\n",
    "        x: output from attention (batch_size, seq_length, d_model)\n",
    "    Returns:\n",
    "        expanded-and-contracted representation (batch_size, seq_length, d_model)\n",
    "    \"\"\"\n",
    "    return self.w_2(self.dropout(self.w_1(x).relu()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LLAMA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RMSNorm(torch.nn.Module):\n",
    "    def __init__(self, dim: int, eps: float = 1e-6):\n",
    "        super().__init__()\n",
    "        self.eps = eps\n",
    "        self.weight = nn.Parameter(torch.ones(dim))\n",
    "    def _norm(self, x):\n",
    "        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)\n",
    "    def forward(self, x):\n",
    "        output = self._norm(x.float()).type_as(x)\n",
    "        return output * self.weight\n",
    "\n",
    "class FeedForward(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        dim: int,\n",
    "        hidden_dim: int,\n",
    "        multiple_of: int,\n",
    "        ):\n",
    "        super().__init__()\n",
    "        hidden_dim = int(2 * hidden_dim / 3)\n",
    "        hidden_dim = multiple_of * ((hidden_dim + multiple_of - 1) // multiple_of)\n",
    "        self.w1 = ColumnParallelLinear(\n",
    "            dim, hidden_dim, bias=False, gather_output=False, init_method=lambda x: x\n",
    "        )\n",
    "        self.w2 = RowParallelLinear(\n",
    "            hidden_dim, dim, bias=False, input_is_parallel=True, init_method=lambda x: x\n",
    "        )\n",
    "        self.w3 = ColumnParallelLinear(\n",
    "        dim, hidden_dim, bias=False, gather_output=False, init_method=lambda x: x\n",
    "        )\n",
    "    def forward(self, x):\n",
    "        return self.w2(F.silu(self.w1(x)) * self.w3(x))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "chatpdf",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
